package com.swagger.demo.util;


import com.swagger.demo.enums.DatePattern;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.Calendar;
import java.util.Date;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * creat by
 *
 * @author heyang
 * @date 2020/9/10 15:49
 */
public class DateUtil {


    private static Logger logger = LoggerFactory.getLogger(DateUtil.class);

    /**
     * 日期时分秒
     */

    public static final String SF = "\\d{4}-\\d{1,2}-\\d{1,2}\\s\\d{2}:\\d{2}:\\d{2}";

    /**
     * 日期时分
     */
    public static final String SFM = "\\d{4}-\\d{1,2}-\\d{1,2}\\s\\d{2}:\\d{2}";

    //ThreadDateUtil
    public static final String SF_YEAR_MONTH = "yyyy-MM";
    /**
     * yyyy-MM-dd
     */
    public static final String sf1 = "yyyy-MM-dd";                                     // new SimpleDateFormat("");
    /**
     * yyyy-MM-dd HH:mm
     */
    public static final String sfm = "yyyy-MM-dd HH:mm";                               //new SimpleDateFormat("");
    /**
     * yyyy-MM-dd HH:mm:ss
     */
    public static final String sf = "yyyy-MM-dd HH:mm:ss";

    public static final String sf2 = "yyyyMMddHH";
    public static final String[] weekDays = {"周一", "周二", "周三", "周四", "周五", "周六", "周日"};

    public static final String sf3 = "dd";
    public static final String sf4 = "MM月dd日";

    public DateUtil() {
    }

    public static String getNowDateHH() {
        return ThreadDateUtil.getDateFormat(sf2).format(new Date());
    }

    public static String getNow() {
        return ThreadDateUtil.getDateFormat(sf).format(new Date());
    }

    public static String getNow(String format) {
        return ThreadDateUtil.getDateFormat(format).format(new Date());
    }

    public static int getDateToWeek(String datetime, String format) {
        int w = LocalDate.parse(datetime, DateTimeFormatter.ofPattern(format)).getDayOfWeek()
                .getValue();
        return w;
    }

    public static String getMonday() {
        //获取当前时间
        LocalDate local = LocalDate.now();
        //获取今天是周几
        DayOfWeek dayOfWeek = local.getDayOfWeek();
        //算出本周一
        LocalDate monday = local.minusDays(dayOfWeek.getValue() - 1);
        return monday.toString();
    }

    /**
     * 获得当前时间second秒后的时间戳
     *
     * @param second
     * @return
     */
    public static long getCurrentTimeInMillis(int second) {
        Calendar cal = Calendar.getInstance();
        if (second > 0) {
            cal.add(Calendar.SECOND, second);
        }
        return cal.getTimeInMillis();
    }

    /**
     * 获取指定时间的在一周内第几天的日期
     *
     * @param timestamp
     * @param format
     * @param index     一周内的第几天，从周一开始，周日结束，1起始
     * @return
     */
    public static String getThisWeekDay(long timestamp, String format, int index) {
        Instant instant = Instant.ofEpochMilli(timestamp);
        ZoneId zone = ZoneId.systemDefault();
        //获取当前时间
        LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, zone);
        //获取今天是周几
        DayOfWeek dayOfWeek = localDateTime.getDayOfWeek();
        //算出本周一
        LocalDateTime monday = localDateTime.minusDays(dayOfWeek.getValue() - index);
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(format);
        return monday.format(formatter);
    }

    public static String getSunday() {
        //获取当前时间
        LocalDate local = LocalDate.now();
        //获取今天是周几
        DayOfWeek dayOfWeek = local.getDayOfWeek();
        //算出本周日
        LocalDate monday = local.minusDays(dayOfWeek.getValue() - 7);
        return monday.toString();
    }

    public static long getTimeStamp(String dateStr, String format) {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat(format);
            Date date = sdf.parse(dateStr);
            return date.getTime();
        } catch (Exception e) {
            return 0;
        }


    }

    public static String getNowDate() {
        return ThreadDateUtil.getDateFormat(sf1).format(new Date());
    }

    public static String getNowDateSFM() {
        return ThreadDateUtil.getDateFormat(sfm).format(new Date());
    }

    public static Date getNowDate(String format) {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        try {
            return sdf.parse(sdf.format(new Date()));
        } catch (ParseException e) {
            logger.error(e.getMessage(), e);
            return null;
        }
    }

    /**
     * 获取上一个小时时间
     * yyyyMMddHH
     *
     * @param date
     * @return
     */
    public static Long getPreHour(Date date) {
        Calendar calendar = Calendar.getInstance();
        SimpleDateFormat sdf = new SimpleDateFormat(sf2);
        try {
            Date formatDate = sdf.parse(sdf.format(date));
            formatDate.getHours();
            calendar.setTime(formatDate);
            calendar.add(Calendar.HOUR, -1);
        } catch (ParseException e) {
            logger.error(e.getMessage(), e);
            return null;
        }
        return calendar.getTime().getTime();
    }

    /**
     * 获取下一个小时时间
     * yyyyMMddHH
     *
     * @param date
     * @return
     */
    public static Long getNextHour(Date date) {
        Calendar calendar = Calendar.getInstance();
        SimpleDateFormat sdf = new SimpleDateFormat(sf2);
        try {
            Date formatDate = sdf.parse(sdf.format(date));
            calendar.setTime(formatDate);
            calendar.add(Calendar.HOUR, 1);
        } catch (ParseException e) {
            logger.error(e.getMessage(), e);
            return null;
        }
        return calendar.getTime().getTime();
    }

    /**
     * 获取前一天的起始时间
     * yyyyMMddHH
     *
     * @param date
     * @return
     */
    public static String getPreDayStartHH(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.DATE, -1);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        date = calendar.getTime();
        return ThreadDateUtil.getDateFormat(sf2).format(date);
    }

    /**
     * 获取前一天的结束时间
     * yyyyMMddHH
     *
     * @param date
     * @return
     */
    public static String getPreDayEndHH(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.DATE, -1);
        calendar.set(Calendar.HOUR_OF_DAY, 23);
        calendar.set(Calendar.MINUTE, 59);
        calendar.set(Calendar.SECOND, 59);
        date = calendar.getTime();
        return ThreadDateUtil.getDateFormat(sf2).format(date);
    }

    /**
     * 根据时间类型比较时间大小
     *
     * @param source
     * @param traget
     * @param type      "YYYY-MM-DD" "yyyyMMdd HH:mm:ss"  类型可自定义
     * @param 传递时间的对比格式
     * @return 0 ：source和traget时间相同
     * 1 ：source比traget时间大
     * -1：source比traget时间小
     * @throws Exception
     */
    public static int DateCompare(long source, long traget) throws Exception {
        if (source == traget)
            return 0;
        else if (source > traget) {
            return 1;
        } else {
            return -1;
        }
    }

    /**
     * 方法名: getTime
     * 方法描述: 获取当前时间时分
     * 修改时间：2016年12月2日 上午10:12:46
     * 参数 @return 参数说明
     * 返回类型 String 返回类型
     */
    public static String getTime(long time) {
        return ThreadDateUtil.getDateFormat("HH:mm").format(time);
    }

    /**
     * 方法名: getTime
     * 方法描述: 获取当前时间时分
     * 修改时间：2016年12月2日 上午10:12:46
     * 参数 @return 参数说明
     * 返回类型 String 返回类型
     */
    public static String getTime() {
        return ThreadDateUtil.getDateFormat("HH:mm").format(getNowTime());
    }

    /**
     * 方法名: getEndTime
     * 方法描述: (这里用一句话描述这个方法的作用)
     * 修改时间：2016年11月24日 下午9:17:18
     * 参数 @param date
     * 参数 @return 参数说明
     * 返回类型 Date 返回类型
     */
    public static Date getEndTime(Date date) {
        if (date == null) {
            return null;
        }
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.HOUR_OF_DAY, 23);
        calendar.set(Calendar.MINUTE, 59);
        calendar.set(Calendar.SECOND, 59);
        calendar.set(Calendar.MILLISECOND, 999);
        return calendar.getTime();
    }

    /**
     * 方法名: getDate
     * 方法描述: 将long型的时间 字符串 转换为yyyy-MM-dd格式的日期字符串
     * 修改时间：2017年6月19日 下午3:24:45
     * 参数 @param str
     * 参数 @return 参数说明
     * 返回类型 String 返回类型
     */
    public static String getDate(String str) {
        Date d = new Date(StringUtil.parseLong(str));
        return ThreadDateUtil.getDateFormat(sf1).format(d);
    }

    public static Date getSfDate(String str) {
        Date date;
        try {
            if (str.matches(SF)) {
                date = ThreadDateUtil.getDateFormat(sf).parse(str);
            } else if (str.matches(SFM)) {
                date = ThreadDateUtil.getDateFormat(sfm).parse(str);
            } else
                date = ThreadDateUtil.getDateFormat(sf1).parse(str);
            return date;
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 方法名: getDate
     * 方法描述: long 转date
     * 修改时间：2017年6月13日 上午10:50:34
     * 参数 @param dateTime
     * 参数 @return 参数说明
     * 返回类型 Date 返回类型
     */
    public static Date getDate(long dateTime) {
        String date = getDateTime(dateTime);
        Date d = null;
        try {
            d = ThreadDateUtil.getDateFormat(sf).parse(date);
            return d;
        } catch (ParseException e) {
            logger.error("", e);
        }
        return null;
    }

    /**
     * 方法名: getDateByLong
     * 方法描述: long 转成String YYYY-MM-dd
     * 修改时间：2017年6月13日 上午11:41:43
     * 参数 @param dateTime
     * 参数 @return 参数说明
     * 返回类型 String 返回类型
     */
    public static String getDateByLong(long dateTime) {
        Date date = getDate(dateTime);
        return ThreadDateUtil.getDateFormat(sf1).format(date);
    }

    public static String getDateTime(Long date) {
        return getDateTime(date, sf);
    }

    public static String getDateTime(Long date, String format) {
        if (null == date) {
            return "";
        }
        try {
            Date d = new Date(date);
            return ThreadDateUtil.getDateFormat(format).format(d);
        } catch (Exception e) {
            logger.error(" getTime E: {}", date, e);
        }
        return "";
    }

    public static String getTime(Long date) {
        if (null == date) {
            return "";
        }
        try {
            Date d = new Date(date);
            return ThreadDateUtil.getDateFormat(sf).format(d);
        } catch (Exception e) {
            logger.error(" getTime E: {}", date, e);
        }
        return "";
    }

    /**
     * 方法名: getStartTime
     * 方法描述: 获取当前0点
     * 修改时间：2017年5月8日 下午5:03:49
     * 参数 @return 参数说明
     * 返回类型 Long 返回类型
     */
    public static long getStartTime() {
        Calendar todayStart = Calendar.getInstance();
        todayStart.set(Calendar.HOUR_OF_DAY, 0);
        todayStart.set(Calendar.MINUTE, 0);
        todayStart.set(Calendar.SECOND, 0);
        todayStart.set(Calendar.MILLISECOND, 0);
        return todayStart.getTime().getTime();
    }

    /**
     * 方法名: getEndTime
     * 方法描述: 获取当天结束时间
     * 修改时间：2017年5月8日 下午5:04:12
     * 参数 @return 参数说明
     * 返回类型 long 返回类型
     */
    public static long getEndTime() {
        Calendar todayEnd = Calendar.getInstance();
        todayEnd.set(Calendar.HOUR_OF_DAY, 23);
        todayEnd.set(Calendar.MINUTE, 59);
        todayEnd.set(Calendar.SECOND, 59);
        todayEnd.set(Calendar.MILLISECOND, 999);
        return todayEnd.getTime().getTime();
    }

    /**
     * 方法名: getStartTime
     * 方法描述: 获取当前0点
     * 修改时间：2017年5月8日 下午5:03:49
     * 参数 @return 参数说明
     * 返回类型 Long 返回类型
     *
     * @throws ParseException
     */
    public static long getStartTime(String dateStr) throws ParseException {
        if (StringUtil.isBlank(dateStr)) {
            return 0;
        } else {
            Date date = ThreadDateUtil.getDateFormat(sf1).parse(dateStr);
            Calendar cal = Calendar.getInstance();
            cal.setTime(date);
            cal.set(Calendar.HOUR_OF_DAY, 0);
            cal.set(Calendar.MINUTE, 0);
            cal.set(Calendar.SECOND, 0);
            cal.set(Calendar.MILLISECOND, 0);
            return cal.getTime().getTime();
        }

    }

    /**
     * 方法名: getEndTime
     * 方法描述: 获取当天结束时间
     * 修改时间：2017年5月8日 下午5:04:12
     * 参数 @return 参数说明
     * 返回类型 long 返回类型
     *
     * @throws ParseException
     */
    public static long getEndTime(String dateStr) throws ParseException {
        if (StringUtil.isBlank(dateStr)) {
            return 0;
        } else {
            Date date = ThreadDateUtil.getDateFormat(sf1).parse(dateStr);
            Calendar todayEnd = Calendar.getInstance();
            todayEnd.setTime(date);
            todayEnd.set(Calendar.HOUR_OF_DAY, 23);
            todayEnd.set(Calendar.MINUTE, 59);
            todayEnd.set(Calendar.SECOND, 59);
            todayEnd.set(Calendar.MILLISECOND, 999);
            return todayEnd.getTime().getTime();
        }
    }

    /**
     * 获取 指定时间毫秒数的0点
     *
     * @param time
     * @return
     */
    public static long getStartTime(long time) {
        Calendar cal = Calendar.getInstance();
        cal.setTimeInMillis(time);
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MILLISECOND, 0);
        return cal.getTime().getTime();
    }

    /**
     * 获取 指定时间毫秒数的23点59分59秒999毫秒
     *
     * @param time
     * @return
     */
    public static long getEndTime(long time) {
        Calendar todayEnd = Calendar.getInstance();
        todayEnd.setTimeInMillis(time);
        todayEnd.set(Calendar.HOUR_OF_DAY, 23);
        todayEnd.set(Calendar.MINUTE, 59);
        todayEnd.set(Calendar.SECOND, 59);
        todayEnd.set(Calendar.MILLISECOND, 999);
        return todayEnd.getTime().getTime();
    }

    /**
     * 获取当前时间的前一天
     *
     * @return
     */
    public static long getPreDayTimestamp() {
        //得到一个Calendar的实例
        Calendar ca = Calendar.getInstance();
        //设置时间为当前时间
        ca.setTime(new Date());
        ca.add(Calendar.DATE, -1);
        //结果
        Date lastDay = ca.getTime();
        return lastDay.getTime();
    }

    public static String getDatem(Long date) {
        try {
            Date d = new Date(date);
            return ThreadDateUtil.getDateFormat(sfm).format(d);
        } catch (Exception e) {
            logger.error(" getDatem E: {}", date, e);
        }
        return "";
    }

    public static Long getNowTime() {
        return System.currentTimeMillis();

    }

    /**
     * 获取上周在一年中的星期周期序号。
     *
     * @return
     */
    public static int getLastWeek() {

        Calendar cal = Calendar.getInstance();
        cal.setTime(getThisWeekMonday(new Date()));
        cal.add(Calendar.DATE, -7);

        return cal.get(Calendar.WEEK_OF_YEAR);
    }

    public static Date getThisWeekMonday(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        // 获得当前日期是一个星期的第几天
        int dayWeek = cal.get(Calendar.DAY_OF_WEEK);
        if (1 == dayWeek) {
            cal.add(Calendar.DAY_OF_MONTH, -1);
        }
        // 设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一
        cal.setFirstDayOfWeek(Calendar.MONDAY);
        // 获得当前日期是一个星期的第几天
        int day = cal.get(Calendar.DAY_OF_WEEK);
        // 根据日历的规则，给当前日期减去星期几与一个星期第一天的差值
        cal.add(Calendar.DATE, cal.getFirstDayOfWeek() - day);
        return cal.getTime();
    }

    /**
     * 获取上周星期一的日期
     *
     * @param format
     * @return
     */
    public static String getLastWeekMonday(String format) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(getThisWeekMonday(new Date()));
        cal.add(Calendar.DATE, -7);
        return format(cal.getTime(), format);
    }

    public static String getLastWeekSunday(String format) {

        Calendar cal = Calendar.getInstance();
        cal.setTime(getThisWeekMonday(new Date()));
        cal.add(Calendar.DATE, -1);
        return format(cal.getTime(), format);
    }

    /**
     * 方法名: getTodayEndTime
     * 方法描述: 获取当天结束时间
     * 修改时间：2016年11月2日 下午6:53:23
     * 参数 @return 参数说明
     * 返回类型 Long 返回类型
     */
    public static int getDiffTodayEndTime() {
        return (int) ((getTodayEndTime() - getNowTime()) / 1000);
    }

    /**
     * 方法名: getStartDateTime
     * 方法描述: 获取一天开始time
     * 修改时间：2016年12月5日 上午11:57:01
     * 参数 @param time
     * 参数 @return 参数说明
     * 返回类型 String 返回类型
     */
    public static String getStartDateTime(long time) {
        Date d = new Date(time);
        return ThreadDateUtil.getDateFormat(sf).format(d);
    }

    public static String getStartDateTime(long time, String format) {
        Date d = new Date(time);
        return ThreadDateUtil.getDateFormat(format).format(d);
    }

    /**
     * 方法名: getTodayEndTime
     * 方法描述: 获取当天时间差
     * 修改时间：2016年11月2日 下午6:53:23
     * 参数 @return 参数说明
     * 返回类型 Long 返回类型
     */
    public static Long getTodayEndTime() {
        Calendar todayEnd = Calendar.getInstance();
        todayEnd.set(Calendar.HOUR_OF_DAY, 23);
        todayEnd.set(Calendar.MINUTE, 59);
        todayEnd.set(Calendar.SECOND, 59);
        todayEnd.set(Calendar.MILLISECOND, 999);
        return todayEnd.getTime().getTime();
    }

    public static Long getLongTime(String str) {
        if (StringUtil.isBlank(str)) {
            return getNowTime();
        }
        Date date = null;
        try {
            if (str.matches(SF)) {
                date = ThreadDateUtil.getDateFormat(sf).parse(str);
            } else if (str.matches(SFM)) {
                date = ThreadDateUtil.getDateFormat(sfm).parse(str);
            } else {
                date = ThreadDateUtil.getDateFormat(sf1).parse(str);
            }
        } catch (ParseException e) {
            logger.error(" getLongTime E: {}", str, e);
        }
        if (null == date) {
            return 0L;
        }
        return date.getTime();

    }

    /**
     * 把时间参数 转换为 long
     *
     * @param dateStr
     * @return
     * @throws BackingStoreException
     */
    public static long getTime(String dateStr) throws BusinessException {
        try {
            Date date = ThreadDateUtil.getDateFormat(sf).parse(dateStr);
            return date.getTime();
        } catch (ParseException e) {
            logger.error(" getTime E: {}", dateStr, e);
            throw new BusinessException(" time parese error: " + dateStr);
        }
    }

    /**
     * 方法名: getNowYear
     * 方法描述: 获取当前年份
     * 修改时间：2016年6月22日 下午6:52:24
     * 参数 @return 参数说明
     * 返回类型 String 返回类型
     */
    public static String getNowYear() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy");
        Date date = new Date();
        return sdf.format(date);
    }

    /**
     * 方法名: getFromatTime
     * 方法描述: 转化为所需要的格式日期
     * 修改时间：2017年10月25日 上午11:56:18
     * 参数 @param str
     * 参数 @return 参数说明
     * 返回类型 String 返回类型
     */
    public static String getFromatTime(String str) {
        if (StringUtil.isBlank(str)) {
            return null;
        }
        SimpleDateFormat sdf = new SimpleDateFormat(str);
        Date date = new Date();
        return sdf.format(date);

    }

    /**
     * 方法名: getNowMonth
     * 方法描述: 获取当前年月yyyy/MM
     * 修改时间：2016年6月22日 下午6:52:24
     * 参数 @return 参数说明
     * 返回类型 String 返回类型
     */
    public static String getNowMonth() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM");
        Date date = new Date();
        return sdf.format(date);
    }

    /**
     * 方法名: getNowMonth
     * 方法描述: 获取当前年月
     * 修改时间：2019年3月25日
     * 参数 @return 参数说明
     * 返回类型 String 返回类型
     */
    public static String getNowMonth(String format) {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        Date date = new Date();
        return sdf.format(date);
    }

    /**
     * 方法名: getNowMonthDaySn
     * 方法描述: 获取当前年月yyyyMMdd
     * 修改时间：2017年6月28日 上午10:52:24
     * 参数 @return 参数说明
     * 返回类型 String 返回类型
     */
    public static String getNowMonthDay() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
        Date date = new Date();
        return sdf.format(date);
    }

    /**
     * dq
     * 获取指定年月yyyyMMddHHmmss
     *
     * @param dateTime
     * @return
     */
    public static String getNowMonthDay(long dateTime) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
        Date date = new Date(dateTime);
        return sdf.format(date);
    }

    public static String getAge(String birthDate) {
        if (null == birthDate) {
            throw new RuntimeException("出生日期不能为null");
        }

        int age = 0;
        String[] str = birthDate.split("-");
        if (str.length == 3) {
            Date now = new Date();
            SimpleDateFormat format_y = new SimpleDateFormat("yyyy");
            SimpleDateFormat format_M = new SimpleDateFormat("MM");
            String birth_year = str[0];
            String this_year = format_y.format(now);
            String birth_month = str[1];
            String this_month = format_M.format(now);
            // 初步，估算
            age = Integer.parseInt(this_year) - Integer.parseInt(birth_year);

            // 如果未到出生月份，则age - 1

            if (this_month.compareTo(birth_month) < 0) {
                age -= 1;
            }
            if (age < 0) {
                age = 0;
            }
            return age + "." + (StringUtil.parseInt(this_month) - StringUtil.parseInt(this_month));
        }

        return "0";
    }

    public static String getPreDay(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.DAY_OF_MONTH, -1);
        date = calendar.getTime();
        return ThreadDateUtil.getDateFormat(sf1).format(date);
    }

    /**
     * 方法名: isBirthday
     * 方法描述: 判断输入的字符串是否是合法的生日 生日不能大于当前日期
     * 修改时间：2017年3月22日 上午9:16:09
     * 参数 @param birthday
     * 参数 @return 参数说明
     * 返回类型 boolean 返回类型
     */
    public static boolean isBirthday(String birthday) {
        if (StringUtil.isBlank(birthday)) {
            return false;
        }
        if (birthday.length() != 10) {
            return false;
        }
        Pattern pattern = Pattern
                .compile("^[1,2]\\d{3}(-){1}(0[1-9]||1[0-2])(-){1}(0[1-9]||[1,2][0-9]||3[0,1])$");
        Matcher matcher = pattern.matcher(birthday);
        if (!matcher.matches()) {
            return false;
        }
        Date birth = null;
        try {
            birth = new SimpleDateFormat("yyyy-MM-dd").parse(birthday);
        } catch (ParseException e) {
            logger.error("", e);
        }
        if (!new SimpleDateFormat("yyyy-MM-dd").format(birth).equals(birthday)) {
            return false;
        }
        // 获取当前日期的毫秒数
        long currentTime = System.currentTimeMillis();
        // 获取生日的毫秒数
        long birthTime = birth.getTime();
        // 如果当前时间小于生日，生日不合法。反之合法
        if (birthTime > currentTime) {
            return false;
        }
        return true;
    }

    /**
     * 方法名: isAfterHour
     * 方法描述: 当前时间7点之后可以显示
     * 修改时间：2017年5月11日 下午3:39:34
     * 参数 @return 参数说明
     * 返回类型 boolean 返回类型
     */
    public static boolean isAfterHour() {
        Calendar todayStart = Calendar.getInstance();
        //用d.getHour()可以获取当前小时数。
        int hour = todayStart.get(Calendar.HOUR_OF_DAY);
        return hour >= 7;
    }

    /**
     * wye
     * 获取某天开始时间0:0:0:0
     *
     * @param date
     * @param addDay
     * @return
     */
    public static long getStartTime(Date date, int addDay) {
        Calendar dayTimeStart = Calendar.getInstance();
        dayTimeStart.setTime(date);
        if (addDay != 0) {
            dayTimeStart.add(Calendar.DATE, addDay);
        }
        dayTimeStart.set(Calendar.HOUR_OF_DAY, 0);
        dayTimeStart.set(Calendar.MINUTE, 0);
        dayTimeStart.set(Calendar.SECOND, 0);
        dayTimeStart.set(Calendar.MILLISECOND, 0);
        return dayTimeStart.getTime().getTime();

    }

    /**
     * wye
     * 获取某天结束时间23:59:59:999
     *
     * @param date
     * @param addDay
     * @return
     */
    public static long getEndTime(Date date, int addDay) {
        Calendar dayTimeEnd = Calendar.getInstance();
        dayTimeEnd.setTime(date);
        if (addDay != 0) {
            dayTimeEnd.add(Calendar.DATE, addDay);
        }
        dayTimeEnd.set(Calendar.HOUR_OF_DAY, 23);
        dayTimeEnd.set(Calendar.MINUTE, 59);
        dayTimeEnd.set(Calendar.SECOND, 59);
        dayTimeEnd.set(Calendar.MILLISECOND, 999);
        return dayTimeEnd.getTime().getTime();
    }

    /**
     * wye
     * 获取当前时间 之后或之前的几天
     *
     * @param date
     * @return
     * @throws ParseException
     */
    public static long getLongTimeByDay(long dateTime, int day) {
        Calendar start = Calendar.getInstance();
        start.setTimeInMillis(dateTime);
        start.add(Calendar.DAY_OF_MONTH, day);
        return start.getTime().getTime();
    }

    /**
     * 方法名: getTimeForMessage
     * 方法描述: 夺宝消息列表显示中奖时间
     * 修改时间：2017年8月2日 下午12:39:13
     * 参数 @param timeMinute 分钟
     * 参数 @return 参数说明  天or时or 分
     * 返回类型 int 返回类型
     */
    public static String getTimeForMessage(long timeMinute) {
        int day = (int) (timeMinute / (24 * 60));
        int hour = (int) ((timeMinute % (24 * 60)) / 60);
        int minute = (int) ((timeMinute % (24 * 60)) % 60);
        if (day > 0) {
            return day + "天";
        } else if (hour > 0) {
            return hour + "小时";
        } else {
            minute = minute == 0 ? 1 : minute;
            return minute + "分钟";
        }

    }

    /**
     * 日期格式化字符串
     * 默认格式   yyyy-MM-dd HH:mm:ss
     */
    public static String format(Date date) {
        if (date == null) {
            return null;
        }
        return format(date, DatePattern.YYYY_MM_DD_HHmmss);
    }

    /**
     * 日期格式化字符串
     */
    public static String format(Date date, DatePattern datePattern) {
        if (date == null || datePattern == null) {
            return null;
        }
        return format(date, datePattern.pattern);
    }

    /**
     * 日期格式化字符串
     *
     * @param date    日期对象
     * @param pattern 日期格式
     * @return
     */
    public static String format(Date date, String pattern) {
        if (date == null) {
            return null;
        }
        return ThreadDateUtil.getDateFormat(pattern).format(date);
    }

    /**
     * 日期字符串  转换为日期
     * 默认格式   yyyy-MM-dd HH:mm:ss
     *
     * @throws ParseException
     */
    public static Date parse(String source) throws ParseException {
        return parse(source, DatePattern.YYYY_MM_DD_HHmmss);
    }

    /**
     * 日期格式化字符串
     *
     * @param source      时间字符串
     * @param datePattern 日期格式
     * @return
     * @throws ParseException
     */
    public static Date parse(String source, DatePattern datePattern) throws ParseException {
        return parse(source, datePattern.pattern);
    }

    /**
     * 日期字符串  转换为日期
     *
     * @param source  时间字符串
     * @param pattern 日期格式
     * @return
     * @throws ParseException
     */
    public static Date parse(String source, String pattern) throws ParseException {
        return ThreadDateUtil.getDateFormat(pattern).parse(source);
    }

    /**
     * 日期字符串  转换为日期毫秒数
     * 默认格式   yyyy-MM-dd HH:mm:ss
     *
     * @throws ParseException
     */
    public static Long parseToLong(String source) throws ParseException {
        return parse(source, DatePattern.YYYY_MM_DD_HHmmss).getTime();
    }

    /**
     * 日期字符串  转换为日期毫秒数
     *
     * @param source      时间字符串
     * @param datePattern 日期格式
     * @return
     * @throws ParseException
     */
    public static Long parseToLong(String source, DatePattern datePattern) throws ParseException {
        return parse(source, datePattern.pattern).getTime();
    }

    /**
     * 日期字符串  转换为日期毫秒数
     *
     * @param source  时间字符串
     * @param pattern 日期格式
     * @return
     * @throws ParseException
     */
    public static Long parseToLong(String source, String pattern) throws ParseException {
        return ThreadDateUtil.getDateFormat(pattern).parse(source).getTime();
    }

    /**
     * 功能描述：返回小时
     *
     * @param date 日期
     * @return 返回小时
     */
    public static int getHour(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar.get(Calendar.HOUR_OF_DAY);
    }

    /**
     * 获取日期的部分
     *
     * @param date
     * @param part YEAR = 1 MONTH = 2 DATE = 5
     * @return
     */
    public static int getDatePart(Date date, int part) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar.get(part);
    }

    /**
     * 获取加几月的日期
     *
     * @param date
     * @param month
     */
    public static Date addMonth(Date date, int month) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.MONTH, month);
        return calendar.getTime();
    }

    /**
     * 获取某月的最后一天
     *
     * @param year
     * @param month 0~11
     * @return
     */
    public static String getLastDayOfMonth(int year, int month) {
        Calendar cal = Calendar.getInstance();
        //设置年份
        cal.set(Calendar.YEAR, year);
        //设置月份
        cal.set(Calendar.MONTH, month);
        //获取某月最大天数
        int lastDay = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
        //设置日历中月份的最大天数
        cal.set(Calendar.DAY_OF_MONTH, lastDay);
        //格式化日期
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String lastDayOfMonth = sdf.format(cal.getTime());

        return lastDayOfMonth;
    }

    /**
     * 获取某月的最开始一天
     *
     * @param year
     * @param month 0~11
     * @return
     */
    public static String getFirstDayOfMonth(int year, int month) {
        Calendar cal = Calendar.getInstance();
        //设置年份
        cal.set(Calendar.YEAR, year);
        //设置月份
        cal.set(Calendar.MONTH, month);
        //获取某月最小天数
        int firstDay = cal.getMinimum(Calendar.DAY_OF_MONTH);
        //设置日历中月份的最大天数
        cal.set(Calendar.DAY_OF_MONTH, firstDay);
        //格式化日期
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String firstDayOfMonth = sdf.format(cal.getTime());

        return firstDayOfMonth;
    }

    /**
     * 获取某年某周的日历
     *
     * @param year
     * @param week
     * @return
     */
    public static Calendar getCalendar(int year, int week) {
        Calendar cal = Calendar.getInstance();
        //设置年份
        cal.set(Calendar.YEAR, year);
        //设置周
        cal.set(Calendar.WEEK_OF_YEAR, week);
        //设置该周第一天为星期一
        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
        return cal;
    }

    /**
     * 获取当前日历，每周第一天为 星期一
     *
     * @return
     */
    public static Calendar getThisCalendar() {
        Calendar cal = Calendar.getInstance();
        //设置该周第一天为星期一
        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
        return cal;
    }

    /**
     * 获取周一为一周开始，周日为一周结算，
     * 获取当前时间所在一年中的周数
     *
     * @return
     */
    public static int getweekNumOfYear() {
        Calendar cal = Calendar.getInstance();
        //设置该周第一天为星期一
        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
        cal.setFirstDayOfWeek(Calendar.MONDAY);
        return cal.get(Calendar.WEEK_OF_YEAR);
    }

    /**
     * 获取某年某周的第一天（星期一）
     *
     * @param year
     * @param week
     * @return
     */
    public static String getFirstDayOfWeek(int year, int week) {
        Calendar cal = getCalendar(year, week);
        //格式化日期
        SimpleDateFormat sdf = new SimpleDateFormat(sf1);
        String date = sdf.format(cal.getTime());

        return date;
    }

    /**
     * 获取某年某周的最后一天（星期日）
     *
     * @param year
     * @param week
     * @return
     */
    public static String getLastDayOfWeek(int year, int week) {
        Calendar cal = getCalendar(year, week);
        cal.add(Calendar.DATE, 6);
        //格式化日期
        SimpleDateFormat sdf = new SimpleDateFormat(sf1);
        String date = sdf.format(cal.getTime());

        return date;
    }

    /**
     * 计算剩余时间，创建时间+有效时长-当前时间。
     *
     * @param createTime
     * @param seconds
     * @return
     */
    public static long getRemainSecond(Long createTime, Long seconds) {
        long i = 0L;
        try {
            i = createTime - System.currentTimeMillis() / 1000 + seconds;
        } catch (Exception e) {
            logger.info("获取剩余时间异常，默认为0。createTime {}, seconds {}", createTime, seconds);
        }
        return i;
    }

    /**
     * 计算剩余时间，结束时间-当前时间。
     *
     * @param endTime
     * @return
     */
    public static long getRemainSecond(Long endTime) {
        long i = 0L;
        try {
            i = endTime - System.currentTimeMillis() / 1000;
        } catch (Exception e) {
            logger.info("获取剩余时间异常，默认为0。endTime {}", endTime);
        }
        return i;
    }

    /**
     * 计算给定时间一年后的时间戳
     */
    public static Long getNextYear(Long time) {
        Date date = new Date(time);// 取时间
        Calendar calendar = Calendar.getInstance();
        SimpleDateFormat sdf = new SimpleDateFormat(sf2);
        try {
            Date formatDate = sdf.parse(sdf.format(date));
            calendar.setTime(formatDate);
            calendar.add(Calendar.YEAR, 1);
        } catch (ParseException e) {
            logger.error(e.getMessage(), e);
            return null;
        }
        return getStartTime(calendar.getTime().getTime());
    }


    /**
     * 获取当月开始时间戳
     */
    public static long getMinDateForMonth() {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date());
        calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMinimum(Calendar.DAY_OF_MONTH));
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        return calendar.getTime().getTime();
    }

    /**
     * 获取当月结束时间戳
     */
    public static long getMaxDateForMonth() {
        Calendar calendar2 = Calendar.getInstance();
        calendar2.setTime(new Date());
        calendar2.set(Calendar.DAY_OF_MONTH, calendar2.getActualMaximum(Calendar.DAY_OF_MONTH));
        calendar2.set(Calendar.HOUR_OF_DAY, 23);
        calendar2.set(Calendar.MINUTE, 59);
        calendar2.set(Calendar.SECOND, 59);
        calendar2.set(Calendar.MILLISECOND, 999);
        return calendar2.getTime().getTime();
    }


}
